/**
 * 通用工具函数库
 */

/**
 * 格式化日期
 * @param {string|Date} dateString 日期字符串或Date对象
 * @param {string} format 格式化模式，默认为 'YYYY-MM-DD'
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(dateString, format = 'YYYY-MM-DD') {
  if (!dateString) return '';
  
  const date = dateString instanceof Date ? dateString : new Date(dateString);
  
  const formatMap = {
    'YYYY': date.getFullYear(),
    'MM': String(date.getMonth() + 1).padStart(2, '0'),
    'DD': String(date.getDate()).padStart(2, '0'),
    'HH': String(date.getHours()).padStart(2, '0'),
    'mm': String(date.getMinutes()).padStart(2, '0'),
    'ss': String(date.getSeconds()).padStart(2, '0')
  };
  
  return format.replace(/YYYY|MM|DD|HH|mm|ss/g, match => formatMap[match]);
}

/**
 * 截取内容摘要，去除HTML标签
 * @param {string} content HTML内容
 * @param {number} length 截取长度
 * @returns {string} 处理后的摘要
 */
export function getSummary(content, length = 120) {
  if (!content) return '';
  // 去除HTML标签后截取指定长度字符
  return content.replace(/<[^>]+>/g, '').substring(0, length) + (content.length > length ? '...' : '');
}

/**
 * 防抖函数
 * @param {Function} fn 要执行的函数
 * @param {number} delay 延迟时间，单位毫秒
 * @returns {Function} 防抖后的函数
 */
export function debounce(fn, delay = 300) {
  let timer = null;
  
  return function(...args) {
    if (timer) {
      clearTimeout(timer);
    }
    
    timer = setTimeout(() => {
      fn.apply(this, args);
      timer = null;
    }, delay);
  };
}

/**
 * 节流函数
 * @param {Function} fn 要执行的函数
 * @param {number} limit 时间阈值，单位毫秒
 * @returns {Function} 节流后的函数
 */
export function throttle(fn, limit = 300) {
  let inThrottle = false;
  
  return function(...args) {
    if (!inThrottle) {
      fn.apply(this, args);
      inThrottle = true;
      setTimeout(() => {
        inThrottle = false;
      }, limit);
    }
  };
}

/**
 * 深度克隆对象
 * @param {Object} obj 要克隆的对象
 * @returns {Object} 克隆后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  if (obj instanceof Object) {
    const copy = {};
    Object.keys(obj).forEach(key => {
      copy[key] = deepClone(obj[key]);
    });
    return copy;
  }
}

/**
 * 获取URL参数
 * @param {string} name 参数名
 * @returns {string|null} 参数值
 */
export function getUrlParam(name) {
  const search = window.location.search;
  const reg = new RegExp(`(^|&)${name}=([^&]*)(&|$)`);
  const result = search.substring(1).match(reg);
  
  return result ? decodeURIComponent(result[2]) : null;
}

/**
 * 将扁平数组转为树形结构
 * @param {Array} items 扁平数组
 * @param {string} idKey ID字段名
 * @param {string} parentKey 父ID字段名
 * @param {any} parentValue 根节点的父ID值
 * @returns {Array} 树形结构数组
 */
export function arrayToTree(items, idKey = 'id', parentKey = 'parentId', parentValue = null) {
  const result = [];
  const itemMap = {};
  
  // 先转成map存储
  items.forEach(item => {
    itemMap[item[idKey]] = { ...item, children: [] };
  });
  
  // 构建树形结构
  items.forEach(item => {
    const parent = item[parentKey];
    
    if (parent === parentValue) {
      // 根节点直接加入结果
      result.push(itemMap[item[idKey]]);
    } else if (itemMap[parent]) {
      // 非根节点，找到其父节点添加到children中
      itemMap[parent].children.push(itemMap[item[idKey]]);
    }
  });
  
  return result;
} 